#pragma once
#include <iostream>
#include <queue>
#include <functional>
#include <chrono>
#include <thread>
#include <atomic>
#include <ctime>
#include <csignal>
#include <unistd.h>
#include "threadpool.h"
// 定时任务结构体
struct TimerTask {
    unsigned long interval;     // 任务的触发间隔（毫秒）
    callback cb;   // 任务的回调函数
    void *arg;
    unsigned long trigger_time; // 下次触发时间
    bool operator>(const TimerTask& other) const {
        return trigger_time > other.trigger_time;
    }
};

class Timer {
private:
    std::priority_queue<TimerTask, std::vector<TimerTask>, std::greater<TimerTask>> task_queue;
    bool running;
    timer_t timerid;

    Timer() : running(false) {} // 私有构造函数，禁止外部创建实例

public:
    // 获取 Timer 单例实例
    static Timer& get_instance() {
        static Timer instance;
        return instance;
    }

    // 启动定时器
    void start() {
        running = true;

        // 定义通知方式
        struct sigevent sev {};
        sev.sigev_notify = SIGEV_SIGNAL;
        sev.sigev_signo = SIGUSR1;

        // 创建定时器
        if (timer_create(CLOCK_REALTIME, &sev, &timerid) < 0) {
            perror("timer_create failed");
            exit(1);
        }

        // 设置定时器（10ms 周期，初始延迟1秒）
        struct itimerspec it{};
        it.it_interval.tv_sec = 0;
        it.it_interval.tv_nsec = 10000000; // 每10ms触发一次
        it.it_value.tv_sec = 1;
        it.it_value.tv_nsec = 0;

        if (timer_settime(timerid, 0, &it, nullptr) < 0) {
            perror("timer_settime failed");
            exit(1);
        }

        std::cout << "Timer started" << std::endl;
    }

    // 停止定时器
    void stop() {
        running = false;
        if (timer_delete(timerid) < 0) {
            perror("timer_delete failed");
        } else {
            std::cout << "Timer stopped" << std::endl;
        }
    }

    // 添加任务
    void add_task(const TimerTask& task) {
        TimerTask new_task = task;
        new_task.trigger_time = get_current_time() + new_task.interval;
        task_queue.push(new_task);
    }

    // 获取当前时间（毫秒）
    static unsigned long get_current_time() {
        using namespace std::chrono;
        return duration_cast<milliseconds>(system_clock::now().time_since_epoch()).count();
    }

    // 处理定时任务
    void process_tasks() {
        auto current_time = get_current_time();

        while (!task_queue.empty() && task_queue.top().trigger_time <= current_time) {
            TimerTask task = task_queue.top();
            task_queue.pop();
            ThreadPool::getInstance()->addTask(Task(task.cb,task.arg));

            // 重新设置任务的触发时间，假设任务是周期性的
            if (task.interval > 0) {
                task.trigger_time = current_time + task.interval;
                task_queue.push(task);
            }
        }
    }
};

// 信号处理函数，定义在 Timer 类之后
static void handle_signal(int sig) {
    if (sig == SIGUSR1) {
        Timer::get_instance().process_tasks();
    }
}

// int main() {
//     Timer& timer = Timer::get_instance(); // 获取 Timer 单例

//     // 绑定信号处理函数
//     signal(SIGUSR1, handle_signal);

//     // 启动定时器
//     timer.start();

//     // 添加定时任务
//     TimerTask task1 = {500, timer_task,nullptr};
//     timer.add_task(task1);

//     TimerTask task2 = {1000, timer_task2,nullptr};
//     timer.add_task(task2);

//     // 模拟主线程的其他工作
//     std::this_thread::sleep_for(std::chrono::seconds(10));

//     // 停止定时器
//     timer.stop();

//     return 0;
// }
